home *** CD-ROM | disk | FTP | other *** search
/ GFX Sensations 1 / Graphic Sensations - Volume 1.iso / tools / amiga / 3d_tools / irit40s.lha / Irit / cagd_lib / bzr_read.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-30  |  9.6 KB  |  310 lines
  1. /******************************************************************************
  2. * Bzr-Read.c - Bezier handling routines - read from file.              *
  3. *******************************************************************************
  4. * Written by Gershon Elber, Mar. 90.                          *
  5. ******************************************************************************/
  6.  
  7. #include <ctype.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include "cagd_loc.h"
  11.  
  12. /******************************************************************************
  13. * Reads and returns bezier curve(s) list.                      *
  14. * If error is found in reading the file, ErrStr is set to string describing   *
  15. * it and Line to the line it occured in file.                      *
  16. * If no error is detected *ErrStr = NULL.                      *
  17. ******************************************************************************/
  18. CagdCrvStruct *BzrCrvReadFromFile(char *FileName, char **ErrStr, int *ErrLine)
  19. {
  20.     FILE *f;
  21.     char StringToken[LINE_LEN];
  22.     CagdCrvStruct *Crv,
  23.     *CrvTail = NULL,
  24.     *CrvList = NULL;
  25.  
  26.     if ((f = fopen(FileName, "r")) == NULL) {
  27.     *ErrStr = "File not found";
  28.     *ErrLine = 0;
  29.     return NULL;
  30.     }
  31.  
  32.     while (_CagdGetToken(f, StringToken) == TOKEN_OPEN_PAREN) {
  33.     _CagdUnGetToken(StringToken);
  34.         Crv = BzrCrvReadFromFile2(f, FALSE, ErrStr, ErrLine);
  35.  
  36.     if (CrvList == NULL)
  37.         CrvList = CrvTail = Crv;
  38.     else {
  39.         CrvTail -> Pnext = Crv;
  40.         CrvTail = Crv;
  41.     }
  42.     }
  43.  
  44.     fclose(f);
  45.  
  46.     return CrvList;
  47. }
  48.  
  49. /******************************************************************************
  50. * Reads and returns a bezier curve.                          *
  51. * If NameWasRead is TRUE, it is assumed prefix "[CURVE BEZIER" has already    *
  52. * been read. This is useful for a global parser which invokes this routine.   *
  53. * For exactly this reason, the file is NOT closed in the end.              *
  54. * If error is found in reading the file, ErrStr is set to string describing   *
  55. * it and ErrLine to line it occured in file relative to begining of curve.    *
  56. * If no error is detected *ErrStr is set to NULL.                  *
  57. ******************************************************************************/
  58. CagdCrvStruct *BzrCrvReadFromFile2(FILE *f, CagdBType NameWasRead,
  59.                         char **ErrStr, int *ErrLine)
  60. {
  61.     CagdPointType PType;
  62.     TokenNumType Token;
  63.     int i, j, Length, MaxCoord;
  64.     char StringToken[LINE_LEN];
  65.     CagdCrvStruct *NewCrv;
  66.  
  67.     _CagdGlblLineCount = *ErrLine;
  68.  
  69.     if (!NameWasRead) {
  70.     while ((Token = _CagdGetToken(f, StringToken)) != TOKEN_EOF &&
  71.            Token != TOKEN_OPEN_PAREN);
  72.  
  73.     /* We found beginning of definition - read one: */
  74.     if (_CagdGetToken(f, StringToken) != TOKEN_CURVE ||
  75.         _CagdGetToken(f, StringToken) != TOKEN_BEZIER) {
  76.             *ErrStr = "CURVE BEZIER key words expected";
  77.         *ErrLine = _CagdGlblLineCount;
  78.         return NULL;
  79.     }
  80.     }
  81.  
  82.     if ((Token = _CagdGetToken(f, StringToken)) == TOKEN_OPEN_PAREN) {
  83.     if ((*ErrStr = _CagdGetCurveAttributes(f)) != NULL) {
  84.             *ErrStr = "\"[\" expected";
  85.         *ErrLine = _CagdGlblLineCount;
  86.         return NULL;
  87.     }
  88.     }
  89.     else
  90.     _CagdUnGetToken(StringToken);
  91.  
  92.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  93.     sscanf(StringToken, "%d", &Length) != 1) {
  94.     *ErrStr = "BEZIER Number of points expected";
  95.     *ErrLine = _CagdGlblLineCount;
  96.     return NULL;
  97.     }
  98.  
  99.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  100.     strlen(StringToken) != 2 ||
  101.     (StringToken[0] != 'E' && StringToken[0] != 'P') ||
  102.     !isdigit(StringToken[1]) ||
  103.     atoi(&StringToken[1]) > CAGD_MAX_PT_COORD) {
  104.     *ErrStr = "BEZIER Point type expected";
  105.     *ErrLine = _CagdGlblLineCount;
  106.     return NULL;
  107.     }
  108.  
  109.     PType = CAGD_MAKE_PT_TYPE(StringToken[0] == 'P', atoi(&StringToken[1]));
  110.  
  111.     NewCrv = BzrCrvNew(Length, PType);
  112.  
  113.     /* Read the points themselves: */
  114.     MaxCoord = CAGD_NUM_OF_PT_COORD(PType);
  115.     for (i = 0; i < Length; i++) {
  116.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OPEN_PAREN) {
  117.         *ErrStr = "\"[\" expected";
  118.         *ErrLine = _CagdGlblLineCount;
  119.         CagdCrvFree(NewCrv);
  120.         return NULL;
  121.     }
  122.     if (CAGD_IS_RATIONAL_PT(PType)) {
  123.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  124.         sscanf(StringToken, CAGD_FLOAT_READ,
  125.                         &NewCrv -> Points[W][i]) != 1) {
  126.         *ErrStr = "Numeric data expected";
  127.         *ErrLine = _CagdGlblLineCount;
  128.         CagdCrvFree(NewCrv);
  129.         return NULL;
  130.         }
  131.     }
  132.     for (j = 1; j <= MaxCoord; j++) {
  133.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  134.         sscanf(StringToken, CAGD_FLOAT_READ,
  135.                         &NewCrv -> Points[j][i]) != 1) {
  136.         *ErrStr = "Numeric data expected";
  137.         *ErrLine = _CagdGlblLineCount;
  138.         CagdCrvFree(NewCrv);
  139.         return NULL;
  140.         }
  141.     }
  142.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  143.         *ErrStr = "\"]\" expected";
  144.         *ErrLine = _CagdGlblLineCount;
  145.         CagdCrvFree(NewCrv);
  146.         return NULL;
  147.     }
  148.     }
  149.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  150.     *ErrStr = "\"]\" expected";
  151.     *ErrLine = _CagdGlblLineCount;
  152.     CagdCrvFree(NewCrv);
  153.     return NULL;
  154.     }
  155.  
  156.     *ErrLine = _CagdGlblLineCount;
  157.     *ErrStr = NULL;
  158.  
  159.     return NewCrv;
  160. }
  161.  
  162. /******************************************************************************
  163. * Reads and returns a bezier surface.                          *
  164. * If error is found in reading the file, ErrStr is set to string describing   *
  165. * it and ErrLine to the line it occured in file.                  *
  166. * If no error is detected *ErrStr = NULL.                      *
  167. ******************************************************************************/
  168. CagdSrfStruct *BzrSrfReadFromFile(char *FileName, char **ErrStr, int *ErrLine)
  169. {
  170.     FILE *f;
  171.     char StringToken[LINE_LEN];
  172.     CagdSrfStruct *Srf,
  173.     *SrfTail = NULL,
  174.     *SrfList = NULL;
  175.  
  176.     if ((f = fopen(FileName, "r")) == NULL) {
  177.     *ErrStr = "File not found";
  178.     return NULL;
  179.     }
  180.  
  181.     while (_CagdGetToken(f, StringToken) == TOKEN_OPEN_PAREN) {
  182.     _CagdUnGetToken(StringToken);
  183.         Srf = BzrSrfReadFromFile2(f, FALSE, ErrStr, ErrLine);
  184.  
  185.     if (SrfList == NULL)
  186.         SrfList = SrfTail = Srf;
  187.     else {
  188.         SrfTail -> Pnext = Srf;
  189.         SrfTail = Srf;
  190.     }
  191.     }
  192.  
  193.     fclose(f);
  194.  
  195.     return SrfList;
  196. }
  197.  
  198. /******************************************************************************
  199. * Reads and returns a bezier surface.                          *
  200. * If NameWasRead is TRUE, it is assumed prefix "[SURFACE BEZIER" has already  *
  201. * been read. This is useful for a global parser which invokes this routine.   *
  202. * For exactly this reason, the file is NOT closed in the end.              *
  203. * If error is found in reading the file, ErrStr is set to string describing   *
  204. * it and ErrLine to the line it occured in file.                    *
  205. * If no error is detected *ErrStr = NULL.                      *
  206. ******************************************************************************/
  207. CagdSrfStruct *BzrSrfReadFromFile2(FILE *f, CagdBType NameWasRead,
  208.                         char **ErrStr, int *ErrLine)
  209. {
  210.     CagdPointType PType;
  211.     TokenNumType Token;
  212.     int i, j, ULength, VLength, MaxCoord;
  213.     char StringToken[LINE_LEN];
  214.     CagdSrfStruct *NewSrf;
  215.  
  216.     _CagdGlblLineCount = *ErrLine;
  217.  
  218.     if (!NameWasRead) {
  219.     while ((Token = _CagdGetToken(f, StringToken)) != TOKEN_EOF &&
  220.            Token != TOKEN_OPEN_PAREN);
  221.  
  222.     /* We found beginning of definition - read one: */
  223.     if (_CagdGetToken(f, StringToken) != TOKEN_SURFACE ||
  224.         _CagdGetToken(f, StringToken) != TOKEN_BEZIER) {
  225.         *ErrStr = "SURFACE BEZIER key words expected";
  226.         *ErrLine = _CagdGlblLineCount;
  227.         return NULL;
  228.         }
  229.     }
  230.  
  231.     if ((Token = _CagdGetToken(f, StringToken)) == TOKEN_OPEN_PAREN) {
  232.     if ((*ErrStr = _CagdGetSurfaceAttributes(f)) != NULL) {
  233.         *ErrStr = "\"[\" expected";
  234.         *ErrLine = _CagdGlblLineCount;
  235.         return NULL;
  236.     }
  237.     }
  238.     else
  239.     _CagdUnGetToken(StringToken);
  240.  
  241.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  242.         sscanf(StringToken, "%d", &ULength) != 1 ||
  243.     (Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  244.     sscanf(StringToken, "%d", &VLength) != 1) {
  245.     *ErrStr = "BEZIER Number of points expected";
  246.     *ErrLine = _CagdGlblLineCount;
  247.     return NULL;
  248.     }
  249.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  250.         strlen(StringToken) != 2 ||
  251.     (StringToken[0] != 'E' && StringToken[0] != 'P') ||
  252.     !isdigit(StringToken[1]) ||
  253.     atoi(&StringToken[1]) > CAGD_MAX_PT_COORD) {
  254.     *ErrStr = "BEZIER Point type expected";
  255.     *ErrLine = _CagdGlblLineCount;
  256.     return NULL;
  257.     }
  258.     PType = CAGD_MAKE_PT_TYPE(StringToken[0] == 'P', atoi(&StringToken[1]));
  259.  
  260.     NewSrf = BzrSrfNew(ULength, VLength, PType);
  261.  
  262.     /* Read the points themselves: */
  263.     MaxCoord = CAGD_NUM_OF_PT_COORD(PType);
  264.     for (i = 0; i < ULength * VLength; i++) {
  265.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OPEN_PAREN) {
  266.         *ErrStr = "\"[\" expected";
  267.         *ErrLine = _CagdGlblLineCount;
  268.         CagdSrfFree(NewSrf);
  269.         return NULL;
  270.     }
  271.     if (CAGD_IS_RATIONAL_PT(PType)) {
  272.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  273.             sscanf(StringToken, CAGD_FLOAT_READ,
  274.                     &NewSrf -> Points[W][i]) != 1) {
  275.         *ErrStr = "Numeric data expected";
  276.         *ErrLine = _CagdGlblLineCount;
  277.         CagdSrfFree(NewSrf);
  278.         return NULL;
  279.         }
  280.     }
  281.     for (j = 1; j <= MaxCoord; j++) {
  282.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  283.             sscanf(StringToken, CAGD_FLOAT_READ,
  284.                         &NewSrf -> Points[j][i]) != 1) {
  285.         *ErrStr = "Numeric data expected";
  286.         *ErrLine = _CagdGlblLineCount;
  287.         CagdSrfFree(NewSrf);
  288.         return NULL;
  289.         }
  290.     }
  291.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  292.         *ErrStr = "\"]\" expected";
  293.         *ErrLine = _CagdGlblLineCount;
  294.         CagdSrfFree(NewSrf);
  295.         return NULL;
  296.     }
  297.     }
  298.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  299.         *ErrStr = "\"]\" expected";
  300.     *ErrLine = _CagdGlblLineCount;
  301.     CagdSrfFree(NewSrf);
  302.     return NULL;
  303.     }
  304.  
  305.     *ErrStr = NULL;
  306.     *ErrLine = _CagdGlblLineCount;
  307.  
  308.     return NewSrf;
  309. }
  310.